#ifndef LIST_H
#define LIST_H


/**
  容器中定义了，好多的typedef，需要一点点往上找，找到 typedef 的实际类型。
*/
namespace list_2_9
{
    template <class T>
    struct __list_node {
        typedef void* void_pointer;
        void_pointer prev;
        void_pointer next;
        T data;
    };

    template<class T, class Ref, class Ptr>
    struct __list_iterator{
        typedef T   value_type;
        typedef Ref reference;
        typedef Ptr pointer;
        typedef bidirectional_iterator_tag iterator_category;//使用一种标签来表明它的特性
        typedef ptrdiff_t difference_type;  //固定的长度，如果容器添加的元素超过这个长度，可能会爆掉

        typedef __list_iterator<T, Ref, Ptr> self;
        typedef __list_node<T>* link_type;
        link_type node;

        reference operator*() const { return (*node).data; }
        pointer operator->() const { return &(operator *());}///等同于 ===> &((*node).data) 可实现元素类型-> 的效果
        self& operator++ ()
        { node = (link_type)((*node).next); return *this; }

        self operator++ (int)
        { self tmp = *this;  ++*this;  return tmp;}
        /**
          后置++的代码执行流程
          1. 记录原值
            self tmp = *this;
            此处的不会调用operator* 来处理this，执行的是 copy cotr ，用以创建 tmp 并以 *this 为初值。
            __list_iterator(const iterator& x) : node(x.node) {}
            当*this 当做ctor 的参数后，就不调用operator* 的重载函数
          2. 进行操作
*/
        /**
          关于 前置++ 的返回值为引用，后置++ 返回值为对象的原因：
          向整型操作致敬，因为 C++ 允许两次前置++，而不允许两次后置++。
*/
        /**
          未携带参数的operator++()为前置++，
          携带参数的operator++(int) 为后置++，且这里的int 没有使用
*/
    };


    template <class T, class Alloc = alloc>
    class List {
    protected:
        typedef __list_node<T> list_node;
    public:
        typedef list_node* link_type;
        typedef __list_iterator<T, T&, T*> iterator;
    protected:
        link_type node;

    };




}

namespace list_4_9
{
    template <typename _Tp>
    struct _List_iterator{
        typedef _Tp* pointer;
        typedef _Tp* reference;
    };

    template<typename _Tp,
             typename _alloc = std::allocator<_Tp>>
    class list: protected _List_base<_Tp, _Alloc>
    {
    public:
        typedef _List_iterator<_Tp> iterator;
    };

    struct _List_node_base {
        _List_node_base * _M_next;
        _List_node_base * _M_prev;
    };

    template <typename _Tp>
    struct _List_node
            : public _List_node_base {
        _Tp _M_data;
    };
    /**
      通过继承的方式来获取 头部指针和尾部指针
*/
}

#endif // LIST_H
